byte code :(compiler) .class מהדר בתהליך עורך, סייר, קומפיילר,,JRE וכו'. למשל: אקליפס. נקודות חשובות: חסכון בהקצאת זיכרון.

Size: px

Start display at page:

Download "byte code :(compiler) .class מהדר בתהליך עורך, סייר, קומפיילר,,JRE וכו'. למשל: אקליפס. נקודות חשובות: חסכון בהקצאת זיכרון."

Flora Harrell
5 years ago
Views:

1 1 שיעור 1: שלום עולם, תרגול 2: 1, מחרוזות ומערכים: מפרש :(interpreter) מריץ את הקוד שנכתב בשפת.Java חסרונות: מהדר מאט את מהירות הריצה. גילוי שגיאות רק בזמן ריצה. :(cmpiler) מעבד את קוד התוכנית לפורמט נוח יותר הקומפילציה נבדק התחביר ומתגלות שגיאות. byte cde - הנשמר עם סיומת.class בתהליך יבילות :(Prtability) קוד Java חוצה סביבות, כלומר קוד שקומפל יוכל לרוץ על בכל מחשב ובכל סביבה בה מותקן מפרש לשפה. המכונה המדומה JVM) :(Java Virtual Machine מפרש הנכתב עבור כל סביבה (פלטפורמה), ומכאן שה- JVM כן תלוי סביבה. את ה- JVM לא כותב המתכנת. חבילת ערכת פיתוח JVM) :(Java Develpment Kit כוללת,JVM קומפיילר, דיבגר וכו'. סביבת פיתוח שלובה IDE) :(Integrated Develpment Envirnment סביבה המשלבת כלי פיתוח עצמאיים: עורך, סייר, קומפיילר,,JRE וכו'. למשל: אקליפס. נקודות חשובות: עד סוף שורה text // הערה על מספר שורות /* text */ שמות משתמשים אינם חלק מחתימת המתודה. הערות: שלושה סוגי הערות: סוגי טיפוסים: יסודיים (8 סה"כ), טיפוסי הפניה (מחלקות). יתרונות להגדרת טיפוס מראש: הערת תיעוד javadc /** text */ יעילות זמן חישוב (שלמים לעומת עשרוניים). חסכון בהקצאת זיכרון. סוג מגדיר אילו פעולות ניתן לבצע עליו. תהליך ההשמה הוא אימפרטיבי, חישוב נעשה מימין לשמאל. :Char ייצוג ע"י תו בין ' ל-', או ע"י מספר לפי טבלת ה- unicde. 'n\' שורה חדשה, 't\' טאב. המרת טיפוסים :(Casting) בטיחות ההמרה מתייחסת לסוג הטיפוס ולא לערכו. המרה בטוחה נקראת.widening המרה מפורשת casting) (explicit "לקיחת אחריות" על ההמרה גם אם לא בטוחה,.narrwing כל השמה של מספר מהצורה: X.X (עם נקודה צפה) מתפרש כ- duble ולא כ- flat. משפט (statement) מבצע פעולה; ביטוי (expressin) מבנה שניתן לחשב את ערכו. לרוב משפט לא יחזיר ערך, אך יש שכן, למשל ביטוי השמה. השמה: ++x - מחזיר x ולאחר מכן מקדם; x++ מקדם את איקס ומחזיר אותו עם ערכו החדש.

2 2 השמה מתבצעת מימין x=y=z קודם z ל- y, אח"כ y ל- x ; חיבור, חיסור וכו': משמאל לימין. משתני הפניה: משתנים יסודיים תופסים מקום מוגדר מראש ב- stack, ומשתני הפניה מכילים כתובת לזיכרון ב- heap. יצירת מערך באופן: int[5]; int[] arr = new ייאתחל את חמשת אברי המערך ל- 0, בולייני ל- false. אם שתי הפניות מצביעות לאותו עצם, אין עותק נוסף שלו, אלא ההצבעה היא לאותו מקום בזיכרון. המרת מחרוזת לטיפוס יסודי: Integer.parseInt("<number>") (או Flat או כל אחר). שיעור 2: מבני בקרה, תרגול 2: מבני בקרה, תרגול 3: מבני בקרה: לולאות: אופרטור התנאי <f val> <Blean expressin>? <t val> : שונה ממשפט התנאי if בכך שאינו משפיע על זרימת התוכנית. אופרטור התנאי מחזיר ערך כלשהו. Switch מקבל טיפוס שאינו טיפוס מניה וה- case משווים את הערך אליו. עבור כל תנאי שאינו ב- case ניתן בלוק (בד"כ ימוקם אחרון).default כדי שאחרי התקיימות case נצא מהביטוי, יש לשים,break; אחרת נמשיך לבדוק את שאר ה- caseים. d while,while נבדלים בכך שהשני מבצע ריצה אחת של ה- statement לפני בדיקת התנאי. בלולאות ניתן למקם בחלקי האינקמנטיזציה והאיתחול יותר ממשתנה אחד, ע"י הפרדה בפסיקים. בתוך לולאה ניתן להשתמש ב- break לעצירה מוחלטת של הלולאה או cntinue ליציאה מהאיטרציה הנוכחית של הלולאה ומעבר לבאה. שרותי מחלקה methds) :(static קריאה למתודה ממחלקה אחרת מצריכה שם מלא: name> <class name>.<methd העמסת שירותים: ניתן לכתוב פונקציות בעלות אותו שם, כל עוד החתימה שלהן שונה. שונות תהיה בטיפוס ו/או סוגי ומספר הארגומנטים, אך לא בשמות משתנים. יתרונות: נוחות ערכי ברירת מחדל: אפשרות להעמיס מתודה קצרה עם ערכי ברירת מחדל פנימיים, עבור ערכים שחוזרים על עצמם. תאימות לאחור: במידה וכבר יש מתודה ומשתמשים בה גם במחלקות אחרות, לשנות אותה יפגע בקימפול של קוד משתמש, לכן ניתן להעמיס גרסה חדשה של המתודה כנדרש. בעיה: שכפול קוד. הקומפיילר יחליט איזו העמסה לבחור עבור קלט מסויים, ואם אין העמסה מדוייקת יבצע המרה (אם יוכל), ואם יש תאימות לשתי העמסות יחזיר הודעה על אי בהירות. לשכפול מס' כלשהו של ארגומנטים יש פתרון של תחביר: <array name>).<methd>(<type> משתני מחלקה: משתנים גלובליים למחלקה (או: שדות מחלקה) יוגדרו עם :static מוגדרים בכל המחלקה.

3 3 מוגדרים בזיכרון כל עוד המחלקה בשימוש. מאותחלים לפי ערך ברירת מחדל (גם בלי שניתן להם ערך ספציפי). ישבו ב- Heap ולא ב- Stack. משתנה final ניתן לאתחול פעם אחת בלבד, כל השמה אח"כ תזוהה כשגיאת קומפילציה. שגיאות קומפילציה מול שגיאות זמן ריצה: שגיאות הידור: נתפסות בעת ניסיון להפוך קוד ל- bytecde. שגיאות זמן ריצה: שגיאות שלא ניתן לתפוס בעת הידור. שיעור 3: דיני חוזים, תרגול 3: חוזים: מבני בקרה: כדי לקצר ניתן להשתמש ב- imprt : imprt java.util.smeclass מאפשרת שימוש ישיר ב- smeclass. שימוש ב-*. java.util ייתן את כל תתי המחלקות במקום המתאים ל-* אך לא בצורה רקורסיבית, כלומר לא את כל תתי ותתי-תתי וכו' המחלקות שבמקום *. :static imprt מאפשר ייבוא של משתנה של מחלקה / מתודה. גם כאן ניתן להשתמש ב-*. אין צורך לייבא מאותה חבילה, או את.java.lang :CLASSPATH משתנה סביבה המכיל את שמות התיקיות המכילות מחלקות בהן משתמשים. ניתן להוסיף ארכוב מחלקות מפורמט jar ל- classpath. ו- javadc : (Applicatin Prgramming Interface) API ה- javadc יוצר API אוטומטית בפורמט,HTML והיא חלק מה- JDK. עיצוב לפי חוזה: תנאי קדם ותנאי אחר. לא בודקים תנאי קדם! אחרת הם כבר לא תנאי קדם. ניתן להחזיר לאחר ביצוע מתודה תוצאה חזקה מתנאי האחר שהוגדר. משתמר: תנאי שצריך להתקיים לכל אורך ריצת התוכנה, והוא מגדיר את נכונות התוכנה. הוכחת משתמר היא על פי כללי המתמטיקה. נראות פרטית visibility) :(private מאפשר גישה למשתנה רק מתוך המחלקה בה הוגדר. תיחום באמצעות נראות פרטית מכונה הכמסה.(encapsulatin) משתמר הייצוג: משתמר הקשור לייצוג הפנימי של משתמר כלשהו של התוכנית. למשל: getcunter() == #calls fr m() cunter == calls fr m() כאשר הייצוג הפנימי במימוש של הוא משתמר הייצוג /* קיימים משתמרי ייצוג גם עבור תנאי בתר. נראות: כאשר לא מצויינת דרגת נראות private),(public, ברירת המחדל היא.package

4 4 מחלקות: בנאי: פונקצית אתחול המקצה למופע מחלקה (עצם) מקום על ה- Heap. Heap תכיל משתנים גלובלים ועצמים, לא תלוי במתודה הנוכחית שרצה. Stack משתנים מקומיים וארגומנטים. שרותי מופע בניגוד לשרותי מחלקה methds) (static עובדים על עצמים מסויימים. משתני מופע בניגוד למשתני מחלקה fields) (static הם שדות בתוך עצמים ויחודיים להם. שיעור 4: מחלקות ומנשקים, תרגול 4: מחלקות ועצמים: שירותי מחלקה: בנאי: פונקציית האתחול. שירותי מחלקה: מסומנים static שירותי מופע: לעצם ספציפי, גישה עם אופרטור "." סוגי שרותים: שאילתות, פקודות ובנאים. מצב מופשט ופונקצית הפשטה: תיאור הטיפוס בצורה מדויקת, פשטנית ומתמטית. יצירת חוזה המחלקה בהתאם לצורה זו פונקצית ההפשטה: מיפוי אצמים קונקרטים למצב המופשט. בחוזה: בראש המחלקה <abstract תיאור מצב לאחר הפעלת השרות AF(this) == פונקצית ההפשטה אינה חח"ע (שכן הרבה עצמים יכולים להיות באותו מצב מופשט). שימוש במשתמרי ייצוג להוכחת נכונות גם לגבי המצב המופשט. ניראות תיעוד: javadc תומך בדרגות ניראות שונות (למשל private לא יופיע בתיעוד הציבורי). מנשקים: במנשק יוגדר חוזה ומצב מופשט של הטיפוס. יתרונות למנשקים: צמצום תלות בין קוד הלקוח למימוש הטיפוס גמישות לקוד הלקוח. חופש פעולה במימוש הטיפוס. גמישות בשינויים עתידיים במימוש גמישות ליוצר הטיפוס. לא ניתן להגדיר במנשקים בנאים ומתודות סטטיות. שיעור 5: מנשקים, תרגול 5: מחלקות ועצמים חלק ב': תבנית עיצוב :Factry

5 5 עבור מחלקת אם המשתמשת בטיפוס כלשהו, נרצה לצמצם נראות למנשק, אך אם קיימת תלות גם ככה בין מחלקת האם למחלקה המממשת את המנשק, מהמחלקה המממשת. נגדיר מחלקה חדשה Factry שתייצר כל פעם אובייקט מחלקת האם תשתמש במחלקת המפעל לייצור מופעי המנשק, וישנה תלות בין מחלקת המפעל למימוש. אופציה נוספת: שימוש במנשקים: כדי להפחית תלות בין מחלקת האם למחלקה המממשת, נשתמש במחלקת האם רק במופעים של המנשק, כך שלא תהיה גישה לשדות פנימיים או שירותים שלא הוגדרו במנשק. לטיפוס מסוג מנשק ניתן לבצע השמה של כל טיפוס מחלקה המממשת את המנשק, אך לא הפוך. פולימורפיזם (רב צורתיות): לכל מנשק יכולים להיות מספר מימושים, וקוד המשתמש במנשק לא צריך להתחשב במימוש אחד ספציפי, וכך לשירותים המופיעים במנשק צורות רבות הקומפיילר מוודא שלכל מחלקה מממשת מנשק יש את כל השירותים המוצהרים במנשק. הפונקציה המתאימה שתקרא בזמן ריצה נקרא.dynamic dispatch למימושים שונים. התאמת ניתן להגדיר מערכים של טיפוס מסוג מנשק. ריבוי מנשקים: מחלקה יכולה לממש מספר מנשקים: public <class_name> implements,i1,i2 I3 שיעור 6: מחלקות פנימיות, תרגול 6: מבני נתונים מוכללים, תרגול 7: מחרוזות: מחלקות ושירותים גנריים (מוכללים): הוספת <T> בצמוד לשם המחלקה. טיפוס בתוך המחלקה מוגדר כ-< calss_name><t > ניתן להשתמש ב- T כטיפוס גנרי. הטיפוס הקונקרטי חייב להיות מסוג הפנייה, ולא יכול להיות פרמיטיבי (למשל Integer ולא,(int לכן נשתמש בטיפוסים עוטפים: לכל פרמיטיבי קיים טיפוס עוטף והוא,immutable למשל Integer הוא int ב"עטיפה" ולא ניתן לשנות את תוכנו ברגע שנוצר..<var>.<var type>value ע"י (unbxing) קריאת הערך המוחזק בטיפוס עוטף בג'וואה 5 נעשה bxing, unbxing אוטומטי. מחלקות פנימיות (מקוננות classes :(Nested מבנה תחבירי המבטא היכרות אינטימית בין מחלקות. למשל, טיפוס הנועד לצורכי שימוש טיפוס אחר, הראשון ימומש כמחלקה אינטימית בתוך האחר. רמת ניראות דיפולטית היא רמת המחלקה עצמים מאותה מחלקה יכולים לגשת לעצמים אחרים מאותה מחלקה, גם לשדות פרטיים. למחלקה פנימית גישה לשירותי המחלקה העוטפת, ויש לה שדה הפניה אוטומטית לעצם מהמחלקה העוטפת. אם יש שמות משתנים חוזרים, הדיפולטי יהיה של המחלקה הפנימית, וכדי לגשת לזה של המחלקה העוטפת נשתמש בשם מלא:.<uter_class>.<var_name> יצירת מופע של מחלקה פנימית: בתוך המחלקה העוטפת: יצירה רגילה.

6 6 לא בתוך המחלקה העוטפת: יצירה ע"י uterobej.new innerobj לאובייקט פנימי שלא מקושר למופע של האובייקט החיצוני. כיוון שאין משמעות מחלקה פנימית סטטית: מחלקה פנימית שאינה מקושרת למופע של המחלקה החיצונית. קריאה לה ע"י:.uterClassName.InnerClassName אם מחלקה פנימית סטטית אינה,public צריך ליצור לה.getter למשל: מחלקות פנימיות בתוך מתודות: Outer.Inner bj = new Outer.Inner(); errr Outer.Inner bj = new Outer.getInner(); כאשר הגטר הוא ציבורי במחלקה העוטפת k תחום ההיכרות של המחלקה הפנימית רק בטווח המתודה. יכולה להשתמש במשתני המתודה רק אם הם.final ניתן גם ליצור מחלקות פנימיות אנונימיות. קומפילציה של מחלקות פנימיות יניב קובץ נפרד, class אנונימיות: <uter_name>$1.class וכן הלאה (מספור). ששמו,<uter_name>$<inner_name>.class :Iteratr Design Pattern הפשטה של מעבר על מבנה נתונים, מאפשר סריקת מבנה נתונים ללא הכרת המימוש הפנימי. איטרטור הואמנשק שחייב לממש: hasnext() בודק האם הגענו לסוף. next() גם מחזיר את הנתון וגם מקדם. remve() הסרה של נתון (אופציונלי, לרוב ימומש מימוש ריק {}). כל מחלקה שיש לה איטרטור: Iterable<T> implements (אם היא גנרית עם <T>). פונקציית החזרת האיטרטור נראית כך: Public Iteratr<T> iteratr(){ Return new iteratrimplementatin<t>(args);} מקובל להכניס את מחלקת iteratrimplementatin<t> בתור מחלקה פנימית של הטיפוס. Cllectin<E> מממש את,Iterable<E> ו"מממש" היא 75% מ'. :Strings ניתן לבצע fr each על איטרטור. מחרוזת היא,immutable לכן ניתנת להצבעה ע"י יותר ממשתנה אחד. כל המחרוזות השונות נכנסות ל- pl,string שם נמצאות כל עוד מצביעים עליהן..Insert, append ניתן לבצע עליה.mutable סוג של מחרוזת StringBuffer קיים גם,StringBuilder אבל לא נראה לי שזה חשוב. ועבור

7 7 שיעור 8: 7, הורשה, תרגול 7: בנאים, תרגול 8: תבניות הורשה ומימוש: יחסים בין מחלקות: מכלול :(Aggregatin) יחס המבטא הכלה, למשל :cllectin מכיר את רכיביו, אך הם לא מכירים אותו, לרכיבים אפשרות קיום עצמאית ללא היכללות במיכל. הרכבה :(Cmpsitin) הכלה בה לרכיבים אין יכולת קיום ללא המיכל, למשל טיפוסים המוגדרים במחלקה פנימית בתוך טיפוס המיכל (כמו חדרים בבית, שכן לחדר אין קיום לבדו). יחס :(Generalizatin) is a כאשר מחלקה אחת היא סוג של מחלקה אחרת. הורשה: מחלקה יורשת מקבלת את כל תכונות המורישה. ניתן לרשת אך ורק ממחלקה אחת (לעומת מימוש, שכן מחלקה אחת יכולה לממש מספר מנשקים). בנאים לא עוברים בירושה, ומתודות סטטיות לא עושות אובררייד בירושה. אין ניראות שדות.private ממחלקה שתוגדר final לא ניתן יהיה לרשת. ישנה הורשה בין מנשקים. אתחולים ובנאים: כל בנאי של מחלקה שלא יורשת משום מחלקה אחרת, מכילה בנאי (נסתר) של bject כיוון שכל מחלקה מרחיבה את.bject בנאי של מחלקה יורשת יכיל קריאה לבנאי של המחלקה ממנה יורש ע"י קריאה ל-() super המתאימים. הקריאה הנסתרת לבנאי של bject תהיה ריקה. עם הנתונים דריסה: מחלקה יורשת יכולה לדרוס מתודה מהמורישה ע"י שימוש בחתימה זהה. כדי לקרוא למתודה הנדרסת נשתמש ב:.super.methdName בד"כ נוסיף טיפוס סטטי ודינאמי: טיפוס של עצם הוא טיפוס הבנאי לפיו נוצר העצם והוא בלתי ניתן לשינוי ברגע שנוצר. טיפוס סטטי: הטיפוס שמוגדר בהכרזה על ההפניה (מקדם שם המשתנה) יכול להיות מחלקה או מנשק. טיפוס דינאמי: טיפוס העצם המוצבע, והוא נגזרת של הטיפוס הסטטי. למשל: PlarPint של.IPint ניראות :Prtected מאפשרת גישה לאורך שרשרת הירושה, וברמת החבילה (בשפות מונחות עצמים אחרות ניראות זו לא כוללת אחרים גישה מתת-מחלקה גישה מאותה חבילה את רמת החבילה). סיכום ניראות וירושה: גישה מאותה מחלקה לא לא לא כן Private לא אלא אם המחלקה ותת-המחלקה לא, כן כן (default) Package באותה חבילה לא גם אם המחלקה ותת-המחלקה לא כן, כן כן Prtected באותה חבילה כן כן כן כן Public

8 8 למה prtected בהורשה למה private בהורשה מקיים יחס,is a הגיוני שיהיה בעל אותן זכויות הסתרת המימוש לשמירה על שלמות המידע גם מצאצאים היורש מכיל בתוכו את המוריש, לכן צריך גישה פשוטה יורש עלול לשבור חוזה מוריש, ולשבור את התוכנה אצל הלקוח ונוחה יורש הוא סוג של לקוח, עיקרון הסתרת המידע צריך לחול עליו :Clne, deep_clne Clne יוצר מצביע אל אותו אובייקט. יוצר אובייקט חדש עם שדות חדשים, אך השדות החדשים מצביעים על אותם אובייקטים deep_clne שהשדות הישנים מצביעים (כלומר לא deep_clne רקורסיבי). :abstract class - מחלקה מופשטת :Template methd design pattern לא חייבים לממש מתודות נורשות, ניתן ליצור חתימות של מתודות חדשות בלי מימוש. tp מתודות ממומשות נקראות אלגוריתם כללי, אינן תלויות במימוש הסופי החלפת (כמו במחסנית צריכה להשתמש ב- tp,push, מבלי לדעת כיצד ממומשות)..callbacks או hks מתודות אבסטרקטיות המועברות הלאה נקראות לא ניתן ליצור מופע של מחלקה מופשטת. נועדה למנוע שכפול קוד. אפשר לוותר על הצהרות שמתקבלות מהמנשק ולא ממומשות. המחלקה המופשטת באה לחסוך לספק, לנו, ואילו מנשק ללקוח. Extract superclass אקליפס מאפשר שכתוב מבני (refactring) הנקרא ליצירת מח' אבסט' המאחדת מספר מחלקות יורשות, ומאחדת אוטומטית את הקוד שניתן לאחד. :Adapter Design Pattern תיאום בין מנשק למחלקה שלא מממשת אותו, ע"י מחלקת תיאום. במחלקת התיאום יהיה שדה: <class name, e.g: java.util.randm> <var name, e.g: r>; המחלקה תורכב ממתודות מימוש המנשק, תוך התאמה בין r לנדרש. ניתן לעשות זאת על יותר ממחלקה אחת. :Bridge Design Pattern פתרון לבעיית צורך בירושה מרובה ע"י שימוש בהכלה עם האצלה. למשל, ניצור שני מנשקים לטיפוס, כאשר מחלקה המממשת את הראשון תקבל כשדה (בבנאי) מופע של מימוש המנשק השני, ועל מימושו תוסיף לוגיקה כלשהי (דוגמא במצגת: מחסנית הממומשת ע"י LastMdifiedStack לוגיקה של שמירת שדה תאריך שינוי אחרון, המקבלת בבנאי מופע של מימוש ArrayList של מחסנית לוגיקה מקבילה שאינה מתנגשת עם הראשונה).

9 9 טיפוסי זמן ריצה: בשל הפולימורפיזם, טיפוס כללי: לא ידוע הטיפוס המדויק של עצם, כלומר הטיפוס הדינמי, שניתנות לטיפוסים דינמיים ספציפים. בשביל לפתוח אפשרויות אלו נשתמש ב- casting. סוגי המרות: :Dwncast המרה למטה, בפציפיקציה של הטיפוס. יכול להוות בעיה. :Upcast המרה למעלה למחלקה או מנשק, לא מהווה בעיה (פשוט מאבד מידע). המרה תתבצע כמו בטיפוסים פרמיטיביים: <Expressin> (Type t cast int) בדיקות טרום- casting : מתודת getclass() מחזירה את המחלקה של הטיפוס. למשל הבדיקה: shape.getclass() == Plygn.class וכך נחסמות אפשרויות (shape instancef Plygn) :Instancef בודק האם העצם הנבדק הוא יורש מהטיפוס, או מממש את הטיפוס או מסוג הטיפוס עצמו. ברגע שנוצר טיפוס ספציפי מסוג טיפוס כללי, למשל FCStack<String> אינו סוג של.FCStack<Object> הערות חשובות: אם יצרנו טיפוס כללי, והשמנו בו טיפוס ספציפי, למשל מערך של bject שהכנסנו אליו מערך של,String אם נמלא אותו בערכים שאינם String יעבור קימפול אך ייזרק בזמן ריצה. כמו כן לא ניתן ליצור מערכים של טיפוס גנרי (טעות קומפילציה), אך כן ניתן לעשות casting למערך מטיפוס גנרי. טיפוס נא: אם ישנו טיפוס,smeType<T> ניתן ליצור ממנו טיפוס נא: :בלי לציין את הסוג, שקול ל הסוג הוא הגבול העליון מבחינת טיפוסים, לרוב אובג'קט smetype var = new smetype() smetype<?> var = new smetype<object> במקרה זה כן ניתן לבצע השמה (כן מתקמפל ועלול ליפול בריצה) של הטיפוס הנא לטיפוס ספציפי. השמת גבול לטיפוס כללי: Cmparable> - public class smeclass<t extends למשל, מגביל את T לקבל טיפוסים שמממשים.Cmparable בזמן ריצה אין זכר לפרמטר הטיפוס הכללי, ולכן לא ניתן לקרוא לבנאי לפי הפרמטר הכללי. כדי לכתוב שירות המקבל פרמטר כללי, לא נוכל להשתמש ב-< Object >, כי כפי שנאמר לעיל, נקבל שגיאת זמן ריצה בניסיון השמה של כל מה שאינו בדיוק.Object לצורך כך נשתמש בג'וקר: כך המתודה מוגדרת לקבל כל מיני טיפוסים עם מכנה משותף כלשהו limit)>?> Extends (upper השמת חסם תחתון לטיפוס המתקבל limit)>?> Super (lwer

10 10 ירושה וחוזים: שמורת כל מחלקה צריכה להיות שווה/חזקה משמורת מחלקת הבסיס/המנשק ממנה יורשת/אותו מממשת. תנאים אפקטיבים: מכלול התנאים לאורך עץ הירושה. בכל שלב יוגדרו בחוזה התנאים החדשים בלבד. השמורה האפקטיבית: היא שמורה המורכבת משמורות כל המחלקות בשרשרת הירושה המקושרות ע"י AND (שכן שמורות כל המחלקות בדרך צריכות להתקיים). מהגיון זה, אם בדרך למחלקה כלשהי אין שמורה, ינתן לה ערך ברירת מחדל אמת. תנאי קדם אפקטיבי: תנאי קדם של מחלקה יורכב מ- OR של כל תנאי הקדם של הוריה, שכן החזק מתנאי הקדם יהיה של מחלקת הבסיס (כי לא יכול להיות שמחלקה בשרשרת תצמצם את טווח הפעולה של הוריה, תנאי הקדם שלה יהיה שווה / חלש משל הוריה). מהיגיון זה, אם למחלקה בדרך אין תנאי קדם, כדי שלא תתרום דבר ל- OR, ינתן לה ערך ברירת מחדל שקר. תנאי אחר אפקטיבי: שרשרת AND של תנאי האחר של שרשרת המחלקות בדרך, כאשר ברירת מחדל למחלקה בלי תנאי אחר הוא ערך אמת (שכן במורד עץ הירושה תנאי האחר נשמר או מתחזק). עוד חוקים: במורד עץ ירושה למתודה דורסת מותר להרחיב נראות אך לא לצמצמה. במורד העץ מותר למתודה דורסת לצמצם את טיפוס הערך המוחזר אך לא להרחיבו. תנאי קדם מופשט: תנאי קדם של מתודות אבסטרקטיות או שנדרסו; הוא נשאר ללא שינוי, גם אם תנאי הקדם הקונקרטי שונה ממנו. סיכום: ירושה צריכה לקיים שני תנאים: יחס is a ועקרון ההחלפה. שיעור 9: חריגים: Exceptin תנאים העשויים להתקיים במהלך ריצה תקין, מקרי קצה. מיוצג ע"י :Checked exceptins,errr בעיות חמורות היוצגות ע"י או באג בתוכנית המיוצג ע"י :Unchecked exceptins.runtimeexceptin כל הנ"ל הם טיפוסים שמרחיבים את,Thrwable ובחתימת המתודה נוסיף: thrws <list f exceptins> לעתים נרצה להגדיר תנאי קדם חלש, מהסיבות הנ"ל: חוסר שליטה: חוסר שליטה בגלל בו זמניות: למשל גישה לקובץ, שמרגע בדיקת קיומו עד הפעלת הפעולה עליו הוא עלול להימחק (לכן צריך לתת תנאי קדם חלש יותר, שכן תנאי הקדם שאף פעולה לא תיעשה על הקובץ היא בעייתית). חוסר שליטה בגלל פרוטוקולים: העצם מושפע מפרוטוקול (מהעולם החיצון) ולכן מאבדים שליטה. קושי לבדוק את התנאי: לפעמים בדיקת התנאי עבור הלקוח תיקח כאורך ביצוע המתודה, וכבר לא שווה להריץ אותה... לכן נדרש לתנאי קדם חלש יותר.

11 11 תנאי צד: במקום תנאי קדם, מוכנס תנאי צד: שבמידה וחל לא מוחזר הערך לפי תנאי האחר, אלא נזרק חריג. בלוק :try catch את הקוד הבעייתי נעטוף בבלוק try ואם יזרק חריג, יתפס באחד מבלוקי ה- catch בהתאם ל- exceptin המתקבל. חיפוש handler יתבצע החוצה עד.main אם יש כמה בלוקי catch מתאימים, יתבצע הראשון מביניהם בסדר ההופעה בקוד. בלוק :finally אם נזרק תנאי צד, חובה לבדוק שהמשתמר מתקיים, במידה ושונה בדרך. בלוק ה- finally יחזיק את מה שיתקיים בכל מקרה אחרי ה- try catch. חוזה לא חייב להגדיר את תנאי הצד, אך רצוי. בהצהרת thrws אין חובה להצהיר על unchecked Exceptins כיוון שאלו בעיות חמורות בסביבה/בתוכנית, ואין משמעות לאחר שקרו לקיום המשתמר שכן התוכנית צריכה להיעצר. יצירת חריגים חדשים: הורשה: חריגים הם אובייקטים היורשים מ- Thrwable או צאצאיו. סיבות שחריגים הם עצמים: שניתן יהיה להחזיר בתוכו מידע שיכול להועיל לתיקון הבעיה. שנוכל להודיע למשתמש על החריג. שיכיל מידע שיאפשר התאוששות (נדיר). כל חריג יכיל מינימום: בנאי ריק, בנאי שמקבל מחרוזת, ומתודת getmessage המחזירה מחרוזת. לכל מחלקה יורשת / מתודה דורסת אסור להרחיב את החריגים הנזרקים, אך כמובן שמותר לצמצם את מספרם או לזרוק חריגים היורשים מהחריגים שירשה, כלומר להקל בסה"כ על הלקוח. תרגול :9 :I/O זרמים: זרם הוא כמו צינור להעברת מידע. כל זרם נפתח אוטומטית ברגע שנוצר. יש זרמי קריאה וכתיבה: קריאה: InputStream לקריאת בתים, Reader לקריאת תווים..Writer,OutputStream כתיבה: כל הנ"ל הן מחלקות אבסטרקטיות. זרמים סטנדרטים לקלט,InputStream פלט ושגיאות System.in, System.ut, System.err.(PrintStream) מקבלים בבנאי זרם ומוסיפים עליו אופציות. Scanner למשל מחלקת זרם ל- tkens Wrappers ומאפשרת להוציא את ה- int הבא, ה- char הבא, שורה וכו'. ניתן לשנות לה.delimiter מחלקה :File אין מה לכתוב את כל הפקודות. :Object serializatin Object serializatin מאפשר שמירת וקריאת אובייקטים מזרם בתים. מנשק Serializable מנשק ריק, רוב המחלקות הן,Serializable ותתי מחלקות של מחלקות Serializable הן גם כאלו.

12 12 שיעור :10,GUI תרגול :10 :GUI כל דבר ב- GUI הוא.widget עצמים ודברים חשובים: Display מייצג את המסך. Shell עצמים של חלונות, ההורה הוא המסך. Event lp לולאה הרצה וממתינה לפקודות. יש לשחרר משאבים גרפיים בסוף שימוש, כגון.display במתודת יצירת ה- shell נגדיר: ניצור אובייקט מסוג,Shell נגדיר את הכותרת שלו. Shell.setLayut הגדרת סוג התבנית: עמודות, שורות....setLayutData ע"י Layut לו גם נגדיר לכל אובייקט שניצור ונשים ב- shell, מאזינים: לכל רכיב ניתן להוסיף מאזין ע"י מחלקות אנונימיות pattern),(bserver design דוגמא: adapters מוסיף מאזין ללחיצה על הכפתור Buttn.addSelectinListener( - מחלקות שיודעות כאשר האירוע לו מאזינים קרה, אך לא SelectinAdapter(){ new מבצעות כלום. מהם אנחנו נירש ונדרוס את המתודה.widgetSelected }); Public vid widgetselect(selectinevent e){ } <d smething> כאשר קורה אירוע, כל מאזין נודע על כך, ומשחרר את האדפטר המוגדר. יכולים להיות כמה מאזינים לאירוע. ניתן גם להשתמש במאזין לא ספציפי Listener() new ובמחלקה האנונימית תהיה המתודה (e public vid handleevent(event שתבצע משהו (עבור כל event שתקבל). הערה: ניתן לממש מאזינים גם בדרכים אחרות, כגון מחלקה יורשת מאובייקט שתממש,listener או הכלה של כפתור במחלקה נפרדת (האצלה), או מחלקה פנימית שאינה אנונימית. פורש את ה- shell. shell.pack פותח את ה- shell. shell.pen פריסה: פריסה מתבצעת מלמעלה למטה, כלומר פריסת עצמים בתוך אובייקט תתבצע לאחר שגודל האובייקט נקבע. :Cmpsites מאפשרים מודולריות של פריסה.

13 13 שיעור 11: מקביליות ורשתות: תקשורת בין מחשבים: פרוטוקול תקשורת: מתאר את תחלופת המידע בין מחשבים. המידע אינו תלוי שפת התכנות בה נכתבו התוכניות המדברות באמצעות פרוטוקול, וישנם תקנים סטנדרטיים לפרוטוקלים (ציבוריים). לכל מחשב מחובר לאינטרנט כתובת אפשרויות לשלוחה -.Prt 4) IP מספרים 256 X אפשרויות), ולכל תוכנית הרצה יש 65,536 תקשורת למחשב תיעשה ע"י פניה לכתובתו עם הודעה מתאימה לפי הפרוטוקול. תקשורת ב- Java : שימוש במחלקה Scket (שקע) לתקשורת עם תוכנית מחשב אחרת. שליחת מחרוזת בין מחשבים: Client יצירת שקע תקשורת 7); Scket(" Scket s = new PrintWriter ut = new PrintWriter( s.getoutputstream(), true); הדפסת זרם לשקע התקשורת there!"); ut.println("hell Server יצירת שקע תקשורת ServerScket; ServerScket s = new ממתין לקבלת מידע s.accept(); Scket clientscket = BufferedReader in = new BufferedReader( קריאת הזרם ( InputStreamReader new clientscket.getinputstream())); שמירה במחרוזת in.readline; String input = תכנות מרובה חוטים :(Threads) חוטים ב- Java הם אובייקט מסוג.Thread חוט מריץ מתודה עם חתימה קבועה: run(),public vid פרט לראשי המריץ את main() מחלקה המממשת את run() מממשת את.Runnable.Runnable הוא עצם שהועבר אליו מופע של מחלקה המממשת את Thread מספר חוטים יכולים לרוץ על אותו אובייקט במקביל, ולחלוק מידע. חסרונות לשימוש ב- sckets : פרוטוקול לא סטנדרטי: היישום מגדיר פרוטוקול משלו, וכדי להשתמש בתוכנית לקוחות יצטרכו להתקין clients שלה. דפדפנים: הטכנולוגיה תופסת חלק נכבד מהקוד: לעומת הלוגיקה העסקית (התופסת חלק קטן בקוד). דפדפנים מחלקים את ה- URL שהוכנס לחמישה חלקים: Prtcl ברירת המחדל. Hst /<path>/index.html - File.http ברירת המחדל של 80 :Prt

14 14 עבודה עם פרוטוקול http ב- Java : שימוש במחלקות הנקראות servlets המממשות לוגיקות עסקיות אותן נטען לשרת - ה- cntainer.web השרותון הנשלח מקבל את כל מה שצריך מהשרת, עליו לממש רק את dget שהוא.hk כתיבת שרותון: <servlet_name> extends HttpServelt בנאי ריק HttpServletRequest, HttpServletRespnse המקבלת dget לפונקצית Override השרותונים הם סינגלטון, לכן אם כמה לקוחות ניגשים לאותו שירותון, הם מופנים לאותו עצם בזיכרון. פעולות השרת :HttpServer יצירת שקע והמתנה ללקוחות. עבור כל הודעה חדשה שמקבל: קרא שורה ראשונה בהודעה. :GET אם זו הודעת ניתוח המחרוזת לחילוץ שם השרותון המבוקש עם שמות המשתנים וערכיהם. קבל הפניה לשרותון המתאים. צור את מחלקות העזר Respnse).(Request, אם השרותון נמצא, קרא ל- dget על השרותון ומחלקות העזר, אחרת הצג שגיאה. תרגול :11 Types :Enumerated טיפוסי מניה הם טיפוסים קבועים ברי מניה (כמו למשל קלפים: עלה, תלתן, לב, ויהלום). מבנה הטיפוס: public enum Suit{ SPADES, HEARTS, DIAMONDS, CLUBS } ואז ניתן לבצע על טיפוס ממחלקה זו.switch כמו כן ניתן להוסיף בנאי למחלקה שיקבל כמחרוזת את שם המחלקה, וניתן להוסיף לכל סוג שם, למשל:.SPADES("Spades") טיפוס EnumMap,EnumSet כל ערכי הקבוצה באים מ- enum קיים. מאפשר ליצור קבוצה המחזיקה יותר מסוג אחד מה- enum, כלומר יותר מתכונה אחת (כמו צורות היכולות להיות בו"ז: עגולה, מלאה וכו') הייצוג הפנימי הוא בביטים (יעיל). למשל: types>) Set<smeEnumType> s = EnumSet.f(smeEnumType.type1, <sme mre או: EnumSet.allOf(smeEnumType.class) Set<smeEnumType> s = יכיל את כל הסוגים. EnumMap עובד בצורה דומה.

ASP.Net MVC + Entity Framework Code First.

ASP.Net MVC + Entity Framework Code First 1 הקדמה בפרק הזה יוצג שימוש בFirst EntityFramework Code עבור ה use case הבאים : ASP.Net MVC ASP.Net Web API ASP.Net MVC + Scaffolding הערה : Framework Entity הוצג